import random
import time
from collections import Counter
# 无敌计算
class WudiItem():
    def __init__(self,z,ps,t,info):
        self.z = z  # 0未中，1中
        self.ps = ps    # 赔率值
        self.t = t  # 时间戳
        self.info = info   # 其他信息

# class WudiFind():
#     def __init__(self,dx,mzl):

#   无敌算法分析
class WudiAnalysis():
    def __init__(self,ds,mzl):
        self.ds = ds
        self.mzl = mzl

    # 预测
    def yuce(self):
        pass

    def get_mzl(self,dx):
        mzl = 0
        if dx:
            dxres = Counter(dx)
            if dxres.get(1):
                mzl = round(dxres.get(1) / len(dx), 4)
        return mzl
    #
    def test(self):
        if self.ds:
            # 排序，时间t，以前到现在
            ds_xu = sorted(self.ds, key=lambda x: x.t, reverse=False)
            # for d in ds_xu:
            #     print(d.z,d.ps,d.t,d.info)
            #   计算间隔数  1/命中率
            mzl_ge = round(1 / self.mzl, 0)
            # 算法：如果中间连续黑3*ge
            # 找出连续黑的之前2*ge的数据，
            # 判断，如果命中率高于平均命中率，那么预测的数据不能选择，继续等待
            # 否则，可以加入2*ge的等待，
            # 命中一次，即可停止
            #  2*ge|3*ge|？2*ge
            t_mzl_ge = int(mzl_ge)
            c_mzl_ge = 4 * t_mzl_ge
            l_mzl_ge = 3 * t_mzl_ge
            r_mzl_ge = 2 * t_mzl_ge
            # 取出红黑
            dx = [a.z for a in ds_xu]
            print(dx)
            # 统计红黑的次数
            dxres = Counter(dx)
            # 取出红的间隔
            _ge = []
            c = 0
            for index, d in enumerate(dx):
                if l_mzl_ge < index < len(dx) - r_mzl_ge:
                    if d == 0:
                        c += 1
                        if c >= c_mzl_ge:
                            # 开始预测
                            # 再去拿到开始黑前的2*ge开始及结束下标
                            s_index = index - c_mzl_ge - l_mzl_ge
                            # 判断这个区间的命中率
                            s_ge_ds = dx[s_index:index-c_mzl_ge]
                            # 计算命中率
                            mzl = self.get_mzl(s_ge_ds)
                            if mzl < self.mzl:
                                # 如果这个命中率小于平均命中率，说明预测的数据命中的可能性大
                                yuc_index_ds = dx[index:index+r_mzl_ge]
                                print("预测：",yuc_index_ds)
                            else:
                                print("没有出现符合规则的预测数据")

                    else:
                        c = 0

    # 分析
    def analysis(self):
        if self.ds:
            # 排序，时间t，以前到现在
            ds_xu = sorted(self.ds, key=lambda x: x.t, reverse=False)
            # for d in ds_xu:
            #     print(d.z,d.ps,d.t,d.info)
            #   计算间隔数  1/命中率
            mzl_ge = round(1/self.mzl,0)
            # 算法：如果中间连续黑3*ge
            # 找出连续黑的之前2*ge的数据，
            # 判断，如果命中率高于平均命中率，那么预测的数据不能选择，继续等待
            # 否则，可以加入2*ge的等待，
            # 命中一次，即可停止
            #  2*ge|3*ge|？2*ge

            # 取出红黑
            dx = [a.z for a in ds_xu]
            # 统计红黑的次数
            dxres = Counter(dx)
            # 取出红的间隔
            _ge = []
            c = 0
            c_index = 0
            for index, d in enumerate(dx):
                if d == 0:
                    c += 1
                else:
                    g = (c,c_index,index)
                    _ge.append(g)
                    c = 0
                    c_index = index

            # print(dx,dxres)
            # print(_ge)







if __name__ == '__main__':
    ds = []
    for i in range(100000):
        d = random.randrange(0, 3)
        z = 0
        if d == 1:
            z = 1
        w = WudiItem(z, random.randint(0, 7), time.time(), i)
        # 休息两秒钟，在玩
        # time.sleep(1)
        ds.append(w)

    wudi = WudiAnalysis(ds,0.33)
    wudi.test()